package com.wicket.okrapp.biz.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.wicket.okrapp.biz.service.dto.req.*;
import com.wicket.okrapp.biz.service.dto.res.*;
import com.wicket.okrapp.common.exception.BizException;
import com.wicket.okrapp.common.util.CommonFunctionHelper;
import com.wicket.okrapp.common.util.RedisUtil;
import java.util.List;
import java.util.stream.Collectors;
import javax.annotation.Resource;

import com.wicket.okrcomponent.integration.dto.CountNumberDataSetsDto;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.wicket.okrapp.base.service.MOmsEvaBatchRelatedSetService;
import com.wicket.okrapp.dal.po.mbg.OmsEvaBatchRelatedSet;
import com.wicket.okrapp.base.service.MOmsEvaluationObjectTargetCycleService;
import com.wicket.okrapp.dal.po.mbg.OmsEvaluationObjectTargetCycle;
import com.wicket.okrapp.common.exception.Assert;
import com.wicket.okrcomponent.integration.dto.ImplementCountNumberDataSetsComRespDto;
import com.wicket.okrcomponent.integration.dto.ImplementCountNumberDataSetsComReqDto;
import com.wicket.okrcalc.integration.dto.CalculateCalcServiceCollectionComRespDto;
import com.wicket.okrcalc.integration.dto.CalculateCalcServiceCollectionComReqDto;
import com.wicket.okrcomponent.integration.FwCompInterfaceModeClient;
import com.wicket.okrcalc.integration.FwCalcCalculationRulesClient;
import com.wicket.okrapp.base.service.MOmsTargetTimingTaskDispatchService;
import com.wicket.okrapp.dal.po.mbg.OmsTargetTimingTaskDispatch;
import com.wicket.okrapp.base.service.dto.req.QueryPlanEvaBatchSetDetailReq;
import java.util.concurrent.Callable;
import com.wicket.okrapp.base.service.dto.req.QueryEvaObjTargetCycleDetailReq;
import com.wicket.okrapp.base.service.dto.req.QueryTimerTaskPlanByPlanIdListReq;
import com.wicket.okrapp.biz.service.dto.common.MultiContentOperateProgressDto;
import java.util.ArrayList;
import com.wicket.okrapp.biz.service.TaskGenService;
import com.wicket.okrapp.base.service.MOmsTargetService;
import com.wicket.okrapp.dal.po.mbg.OmsTarget;
import com.wicket.okrapp.base.service.dto.req.QueryTargetDetailReq;
import com.wicket.okrapp.biz.service.nb.NbProgressPublicTechnicaCapacity;
import com.wicket.okrcomponent.integration.dto.ObtainProgressLoadingBgComRespDto;
import com.wicket.okrcomponent.integration.dto.ObtainProgressLoadingBgComReqDto;
import com.wicket.okrapp.biz.service.ExecuteProgressService;
import com.wicket.okrcomponent.integration.FwCompConfSchemeClient;
import com.wicket.okrapp.base.service.dto.req.QueryTimerTaskPlanDetailReq;

/**
 * @author ：
 * @date ：
 *
 *
 * @version 1.0
 */
@Service
public class ProgressPublicTechnicaCapacityServiceImpl
  implements com.wicket.okrapp.biz.service.ProgressPublicTechnicaCapacityService {

  @Resource
  private RedisUtil redisUtil;
@Resource
  private MOmsEvaBatchRelatedSetService mOmsEvaBatchRelatedSetService;
@Resource
  private MOmsEvaluationObjectTargetCycleService mOmsEvaluationObjectTargetCycleService;
@Resource
  private FwCompInterfaceModeClient fwCompInterfaceModeClient;
@Resource
  private FwCalcCalculationRulesClient fwCalcCalculationRulesClient;
@Resource
  private MOmsTargetTimingTaskDispatchService mOmsTargetTimingTaskDispatchService;
@Resource
  private TaskGenService taskGenService;
@Resource
  private MOmsTargetService mOmsTargetService;
@Resource
  private NbProgressPublicTechnicaCapacity nbProgressPublicTechnicaCapacity;
@Resource
  private ExecuteProgressService executeProgressService;
@Resource
  private FwCompConfSchemeClient fwCompConfSchemeClient;
//@Resource
 //private undefinedService undefinedService;
/**
   * D3回写关闭托底更新状态(公共)[6587]
   * gen by moon at 5/12/2023, 7:14:13 PM
   */
  @Trace(operationName = "D3回写关闭托底更新状态(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public WriteBackCloseProgressStatusComRespDto writeBackCloseProgressStatusCom(WriteBackCloseProgressStatusComReqDto reqDto){
    
      
      if((reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("TOP_UPDATE_TASK_PROGRESS")||reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("TOP_UPDATE_PARENT_STATE")||reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("TOP_UPDATE_OKR_SUBJECT_PERSONAL")||reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("MID_BASIC_UPDATE_PARENT_STATE")||reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("DEPT_TARGET_BOOK_UPDATE_PARENT_STATE"))||(reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("MID_UPDATE_FLEVEL_OBJ_TASK_DUTY_DEPT"))||(reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("MID_UPDATE_ OKR_SUBJECT_DEPT")||reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("MID_UPDATE_OKR_SUBJECT_DEPT"))||(reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("MID_UPDATE_OKR_SUBJECT_PERSONAL"))) {
        //if((D3回写关闭托底更新状态(公共).托底更新进度场景 等于 高层托底更新汇报任务 or D3回写关闭托底更新状态(公共).托底更新进度场景 等于 高层托底更新父子状态等 or D3回写关闭托底更新状态(公共).托底更新进度场景 等于 高层托底更新OKR个人树 or D3回写关闭托底更新状态(公共).托底更新进度场景 等于 中基层托底更新父子状态等 or D3回写关闭托底更新状态(公共).托底更新进度场景 等于 部门目标任务书树更新父子状态) or D3回写关闭托底更新状态(公共).托底更新进度场景 等于 中层托底更新部门目标任务书树 or (D3回写关闭托底更新状态(公共).托底更新进度场景 等于 中层托底更新OKR部门树 or D3回写关闭托底更新状态(公共).托底更新进度场景 等于 基层部门托底更新OKR部门树) or D3回写关闭托底更新状态(公共).托底更新进度场景 等于 基层托底更新OKR个人树)  41086
        
boolean bOOLEAN ;
    OmsEvaBatchRelatedSet omsEvaBatchRelatedSet=new OmsEvaBatchRelatedSet();
  omsEvaBatchRelatedSet.setUpdateTaskOrTree("HAS_ENDED");//sourceId:923416_1_41088
omsEvaBatchRelatedSet.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:923417_1_41088
omsEvaBatchRelatedSet.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:923418_1_41088
if(reqDto!=null){
      omsEvaBatchRelatedSet.setBatchRelatedSetId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:923415_1_41088
    }
  
    /*3-3-09-03修改评价模板批次设置[3034]   */
    Assert.isNull(omsEvaBatchRelatedSet.getBatchRelatedSetId(),"D3回写关闭托底更新状态(公共)-3-3-09-03修改评价模板批次设置-批次相关设置ID不能为空",false);
Assert.isNull(omsEvaBatchRelatedSet.getUpdateTaskOrTree(),"D3回写关闭托底更新状态(公共)-3-3-09-03修改评价模板批次设置-更新任务或树状态不能为空",false);
Assert.isNull(omsEvaBatchRelatedSet.getOperationInductionId(),"D3回写关闭托底更新状态(公共)-3-3-09-03修改评价模板批次设置-操作人就职记录ID不能为空",false);
Assert.isNull(omsEvaBatchRelatedSet.getOperateTime(),"D3回写关闭托底更新状态(公共)-3-3-09-03修改评价模板批次设置-操作时间不能为空",false);
      bOOLEAN = mOmsEvaBatchRelatedSetService.updatePlanEvaBatchSet(omsEvaBatchRelatedSet)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
      }
else if((reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("TOP_UPDATE_WEIGHT_SCORE")||reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("TOP_UPDATE_FLEVEL_OBJ_TASK_DUTY_DEPT"))){
       //elseif((D3回写关闭托底更新状态(公共).托底更新进度场景 等于 高层托底更新权重分 or D3回写关闭托底更新状态(公共).托底更新进度场景 等于 高层托底更新部门目标任务书权重分))  41087
      
boolean bOOLEAN_1 ;
    OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle=new OmsEvaluationObjectTargetCycle();
  omsEvaluationObjectTargetCycle.setRecalculateWeightState("CALCULATE_COMPLETE");//sourceId:923388_1_41089
omsEvaluationObjectTargetCycle.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:923389_1_41089
omsEvaluationObjectTargetCycle.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:923390_1_41089
if(reqDto!=null){
      omsEvaluationObjectTargetCycle.setEvaObjTargetCycleId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:923359_1_41089
    }
  
    /*3-3-09回写目标周期刷新权重分状态[2317]   */
    Assert.isNull(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId(),"D3回写关闭托底更新状态(公共)-3-3-09回写目标周期刷新权重分状态-被评对象目标周期ID不能为空",false);
Assert.isNull(omsEvaluationObjectTargetCycle.getRecalculateWeightState(),"D3回写关闭托底更新状态(公共)-3-3-09回写目标周期刷新权重分状态-重新计算权重分状态不能为空",false);
Assert.isNull(omsEvaluationObjectTargetCycle.getOperationInductionId(),"D3回写关闭托底更新状态(公共)-3-3-09回写目标周期刷新权重分状态-操作人就职记录ID不能为空",false);
Assert.isNull(omsEvaluationObjectTargetCycle.getOperateTime(),"D3回写关闭托底更新状态(公共)-3-3-09回写目标周期刷新权重分状态-操作时间不能为空",false);
      bOOLEAN_1 = mOmsEvaluationObjectTargetCycleService.updateEvaObjTargetCycle(omsEvaluationObjectTargetCycle)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
    }
WriteBackCloseProgressStatusComRespDto retData = new WriteBackCloseProgressStatusComRespDto();
  
  

  
  
return retData;
  }
/**
   * D3执行统计数据集单条进度值(公共)[6561]
   * gen by moon at 5/30/2023, 11:17:09 PM
   */
  @Trace(operationName = "D3执行统计数据集单条进度值(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCountDataSingleProgressComRespDto implementCountDataSingleProgressCom(ImplementCountDataSingleProgressComReqDto reqDto){
    
      
      CalculateCalcServiceCollectionComRespDto calculateCalcServiceCollectionComRespDto_1 =null;
//步骤0: D2-执行统计数据集条数服务(公共) - implementCountNumberDataSetsCom
     ImplementCountNumberDataSetsComRespDto implementCountNumberDataSetsComRespDto = null;
    ImplementCountNumberDataSetsComReqDto implementCountNumberDataSetsComReqDto=new ImplementCountNumberDataSetsComReqDto();
  if(reqDto!=null){
      //simpleList-to-objLists
    for (String item : reqDto.getCountNumberDataSetsList()) {
        // TODO: 2023/5/31 手写代码 
                com.wicket.okrcomponent.integration.dto.CountNumberDataSetsDto oneItem = new CountNumberDataSetsDto();
                if(reqDto!=null){
      oneItem.setCommPrimaryKey(item);//SimpleFieldAssign//sourceId:196212_2
    }

                implementCountNumberDataSetsComReqDto.getCountNumberDataSetsList().add(oneItem);
            }//sourceId:919203_1
    }
  
    /*D2-执行统计数据集条数服务(公共)[5166]   */
    
      implementCountNumberDataSetsComRespDto = fwCompInterfaceModeClient.implementCountNumberDataSetsCom(implementCountNumberDataSetsComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
    
//步骤1: D4-计算服务集合（基础）(公共) - calculateCalcServiceCollectionCom
     CalculateCalcServiceCollectionComRespDto calculateCalcServiceCollectionComRespDto = null;
    if(implementCountNumberDataSetsComRespDto !=null){
          CalculateCalcServiceCollectionComReqDto calculateCalcServiceCollectionComReqDto=new CalculateCalcServiceCollectionComReqDto();
  calculateCalcServiceCollectionComReqDto.setCalcFormula("DIVISION_OF_TWO_NUM");//sourceId:919210_1
calculateCalcServiceCollectionComReqDto.setDecimalPointRules(Long.valueOf(3));//CUSTOM_CONVENTION//sourceId:919216_1
calculateCalcServiceCollectionComReqDto.setDecimalDigitsLastRules("MALING");//sourceId:919217_1
if(reqDto!=null){
      calculateCalcServiceCollectionComReqDto.setCalcPara1(reqDto.getCalcPara1());//SimpleFieldAssign//sourceId:919212_1
    }
if(implementCountNumberDataSetsComRespDto!=null){
      calculateCalcServiceCollectionComReqDto.setCalcPara2(implementCountNumberDataSetsComRespDto.getOutputNum()!=null?Double.valueOf(implementCountNumberDataSetsComRespDto.getOutputNum()):null);//SimpleFieldAssign//sourceId:919213_1
    }
  
    /*D4-计算服务集合（基础）(公共)[5091]   */
    Assert.isNull(calculateCalcServiceCollectionComReqDto.getCalcFormula(),"D3执行统计数据集单条进度值(公共)-D4-计算服务集合（基础）(公共)-通用计算公式不能为空",false);
Assert.isNull(calculateCalcServiceCollectionComReqDto.getCalcPara1(),"D3执行统计数据集单条进度值(公共)-D4-计算服务集合（基础）(公共)-计算入参1不能为空",false);
Assert.isNull(calculateCalcServiceCollectionComReqDto.getCalcPara2(),"D3执行统计数据集单条进度值(公共)-D4-计算服务集合（基础）(公共)-计算入参2不能为空",false);
Assert.isNull(calculateCalcServiceCollectionComReqDto.getDecimalPointRules(),"D3执行统计数据集单条进度值(公共)-D4-计算服务集合（基础）(公共)-小数点规则不能为空",false);
Assert.isNull(calculateCalcServiceCollectionComReqDto.getDecimalDigitsLastRules(),"D3执行统计数据集单条进度值(公共)-D4-计算服务集合（基础）(公共)-小数最后一位规则不能为空",false);
      calculateCalcServiceCollectionComRespDto = fwCalcCalculationRulesClient.calculateCalcServiceCollectionCom(calculateCalcServiceCollectionComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      calculateCalcServiceCollectionComRespDto_1 = calculateCalcServiceCollectionComRespDto;
           }
    
ImplementCountDataSingleProgressComRespDto retData = new ImplementCountDataSingleProgressComRespDto();
  if(calculateCalcServiceCollectionComRespDto_1!=null){
      retData.setCalcResult(calculateCalcServiceCollectionComRespDto_1.getCalcResult());//SimpleFieldAssign//sourceId:919225_1
    }
  

  
  
return retData;
  }
/**
   * D3执行操作单条进度值(公共)[6562]
   * gen by moon at 6/5/2023, 6:52:44 AM
   */
  @Trace(operationName = "D3执行操作单条进度值(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementOperateSingleProgressComRespDto implementOperateSingleProgressCom(ImplementOperateSingleProgressComReqDto reqDto){
    
      
      //virtualUsage M3执行接收字段入参（特殊方法）  44328
      //ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes = null;
    ImplementAcceptFieldReqDto receptionServiceReq=new ImplementAcceptFieldReqDto();
  receptionServiceReq.setCreateInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1010816_1_44328
receptionServiceReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1010817_1_44328
receptionServiceReq.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:1010818_1_44328
if(reqDto!=null){
      receptionServiceReq.setComFloatField(reqDto.getComFloatField());//SimpleFieldAssign//sourceId:922446_1_44328
receptionServiceReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:921901_1_44328
receptionServiceReq.setUpdateProgressSence(reqDto.getUpdateProgressSence());//SimpleFieldAssign//sourceId:921550_1_44328
    }

    /*M3执行接收字段入参（特殊方法）[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getComFloatField(),"D3执行操作单条进度值(公共)-M3执行接收字段入参（特殊方法）-通用数值字段（小数型）不能为空",false);
Assert.isNull(receptionServiceReq.getEntityId(),"D3执行操作单条进度值(公共)-M3执行接收字段入参（特殊方法）-内容表主键ID不能为空",false);
Assert.isNull(receptionServiceReq.getUpdateProgressSence(),"D3执行操作单条进度值(公共)-M3执行接收字段入参（特殊方法）-托底更新进度场景不能为空",false);
Assert.isNull(receptionServiceReq.getCreateInductionId(),"D3执行操作单条进度值(公共)-M3执行接收字段入参（特殊方法）-创建人就职记录ID 不能为空",false);
Assert.isNull(receptionServiceReq.getSpaceId(),"D3执行操作单条进度值(公共)-M3执行接收字段入参（特殊方法）-创建于空间ID不能为空",false);
Assert.isNull(receptionServiceReq.getAppId(),"D3执行操作单条进度值(公共)-M3执行接收字段入参（特殊方法）-创建于联盟应用ID不能为空",false);
      receptionServiceRes = nbProgressPublicTechnicaCapacity.implementAcceptField(receptionServiceReq);



      //virtualUsage M3异步开始（特殊方法）  41096
      //ModelCode: asynchronizationStart
      ImplementAcceptFieldRespDto finalReceptionServiceRes = receptionServiceRes;
      Callable<String> call = new Callable<String>() {

    @Override
    public String call() throws Exception {
        //执行方法
//virtualUsage M3执行业务应用公共字段推送内存（特殊方法）  44327
      //ModelCode: publicFieldCache
        ImplementBizPublicFieldPushMemoryRespDto publicFieldCacheRes = null;
    ImplementBizPublicFieldPushMemoryReqDto publicFieldCacheReq=new ImplementBizPublicFieldPushMemoryReqDto();
  if(finalReceptionServiceRes !=null){
      publicFieldCacheReq.setCreateInductionId(finalReceptionServiceRes.getCreateInductionId());//SimpleFieldAssign//sourceId:1010812_1_44327
publicFieldCacheReq.setSpaceId(finalReceptionServiceRes.getSpaceId());//SimpleFieldAssign//sourceId:1010813_1_44327
publicFieldCacheReq.setAppId(finalReceptionServiceRes.getAppId());//SimpleFieldAssign//sourceId:1010814_1_44327
    }

    /*M3执行业务应用公共字段推送内存（特殊方法）[4520]  用于定时任务执行时，获取定时任务执行所需的公共信息，存入缓存，供定时任务中虚拟用况使用 */
    Assert.isNull(publicFieldCacheReq.getCreateInductionId(),"D3执行操作单条进度值(公共)-M3执行业务应用公共字段推送内存（特殊方法）-创建人就职记录ID 不能为空",false);
Assert.isNull(publicFieldCacheReq.getSpaceId(),"D3执行操作单条进度值(公共)-M3执行业务应用公共字段推送内存（特殊方法）-创建于空间ID不能为空",false);
Assert.isNull(publicFieldCacheReq.getAppId(),"D3执行操作单条进度值(公共)-M3执行业务应用公共字段推送内存（特殊方法）-创建于联盟应用ID不能为空",false);
      publicFieldCacheRes = nbProgressPublicTechnicaCapacity.implementBizPublicFieldPushMemory(publicFieldCacheReq);



if((reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("TOP_UPDATE_TASK_PROGRESS")||reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("TOP_UPDATE_OKR_SUBJECT_PERSONAL")||reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("TOP_UPDATE_PARENT_STATE")||reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("MID_BASIC_UPDATE_PARENT_STATE")||reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("DEPT_TARGET_BOOK_UPDATE_PARENT_STATE"))||(reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("MID_UPDATE_FLEVEL_OBJ_TASK_DUTY_DEPT"))||(reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("MID_UPDATE_ OKR_SUBJECT_DEPT")||reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("MID_UPDATE_OKR_SUBJECT_DEPT"))||(reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("MID_UPDATE_OKR_SUBJECT_PERSONAL"))) {
        //if((D3执行操作单条进度值(公共).托底更新进度场景 等于 高层托底更新汇报任务 or D3执行操作单条进度值(公共).托底更新进度场景 等于 高层托底更新OKR个人树 or D3执行操作单条进度值(公共).托底更新进度场景 等于 高层托底更新父子状态等 or D3执行操作单条进度值(公共).托底更新进度场景 等于 中基层托底更新父子状态等 or D3执行操作单条进度值(公共).托底更新进度场景 等于 部门目标任务书树更新父子状态) or D3执行操作单条进度值(公共).托底更新进度场景 等于 中层托底更新部门目标任务书树 or (D3执行操作单条进度值(公共).托底更新进度场景 等于 中层托底更新OKR部门树 or D3执行操作单条进度值(公共).托底更新进度场景 等于 基层部门托底更新OKR部门树) or D3执行操作单条进度值(公共).托底更新进度场景 等于 基层托底更新OKR个人树)  41040
        
boolean bOOLEAN ;
    OmsEvaBatchRelatedSet omsEvaBatchRelatedSet=new OmsEvaBatchRelatedSet();
  omsEvaBatchRelatedSet.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:940815_1_41696
omsEvaBatchRelatedSet.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:940816_1_41696
if(reqDto!=null){
      omsEvaBatchRelatedSet.setBatchRelatedSetId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:940814_1_41696
omsEvaBatchRelatedSet.setUpdateTaskOrTreeProgress(reqDto.getComFloatField());//SimpleFieldAssign//sourceId:940817_1_41696
    }
  
    /*3-3-09-03更新高中基层评批次设置进度值[6682]   */
    Assert.isNull(omsEvaBatchRelatedSet.getBatchRelatedSetId(),"D3执行操作单条进度值(公共)-3-3-09-03更新高中基层评批次设置进度值-批次相关设置ID不能为空",false);
Assert.isNull(omsEvaBatchRelatedSet.getUpdateTaskOrTreeProgress(),"D3执行操作单条进度值(公共)-3-3-09-03更新高中基层评批次设置进度值-更新任务或树处理进度不能为空",false);
Assert.isNull(omsEvaBatchRelatedSet.getOperationInductionId(),"D3执行操作单条进度值(公共)-3-3-09-03更新高中基层评批次设置进度值-操作人就职记录ID不能为空",false);
Assert.isNull(omsEvaBatchRelatedSet.getOperateTime(),"D3执行操作单条进度值(公共)-3-3-09-03更新高中基层评批次设置进度值-操作时间不能为空",false);
      bOOLEAN = mOmsEvaBatchRelatedSetService.updateUpdateTaskOrTreeProgress(omsEvaBatchRelatedSet)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
      }
else if((reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("TOP_UPDATE_WEIGHT_SCORE")||reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("TOP_UPDATE_FLEVEL_OBJ_TASK_DUTY_DEPT"))){
       //elseif((D3执行操作单条进度值(公共).托底更新进度场景 等于 托底更新权重分 or D3执行操作单条进度值(公共).托底更新进度场景 等于 托底更新部门目标任务书权重分))  41045
      
boolean bOOLEAN_1 ;
    OmsTargetTimingTaskDispatch omsTargetTimingTaskDispatch=new OmsTargetTimingTaskDispatch();
  omsTargetTimingTaskDispatch.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:940808_1_41695
omsTargetTimingTaskDispatch.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:940809_1_41695
if(reqDto!=null){
      omsTargetTimingTaskDispatch.setTimingTaskDispatchId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:940806_1_41695
omsTargetTimingTaskDispatch.setStandbyField5(reqDto.getComFloatField());//SimpleFieldAssign//sourceId:949247_1_41695
    }
  
    /*3-2-09更新调度里面进度值[6681]   */
    Assert.isNull(omsTargetTimingTaskDispatch.getTimingTaskDispatchId(),"D3执行操作单条进度值(公共)-3-2-09更新调度里面进度值-定时任务调度记录ID不能为空",false);
Assert.isNull(omsTargetTimingTaskDispatch.getStandbyField5(),"D3执行操作单条进度值(公共)-3-2-09更新调度里面进度值-备用字段5不能为空",false);
Assert.isNull(omsTargetTimingTaskDispatch.getOperationInductionId(),"D3执行操作单条进度值(公共)-3-2-09更新调度里面进度值-操作人就职记录ID不能为空",false);
Assert.isNull(omsTargetTimingTaskDispatch.getOperateTime(),"D3执行操作单条进度值(公共)-3-2-09更新调度里面进度值-操作时间不能为空",false);
      bOOLEAN_1 = mOmsTargetTimingTaskDispatchService.refreshTimerTaskDispatchNumAtuoAdd(omsTargetTimingTaskDispatch)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
    }
//virtualUsage M3异步结束（特殊方法）  41097
      //ModelCode: asynchronizationEnd
        return "";
    }
};
CommonFunctionHelper.asynExcute(call);
ImplementOperateSingleProgressComRespDto retData = new ImplementOperateSingleProgressComRespDto();
  
  

  
  
return retData;
  }
/**
   * D3执行强托底进入条件判断(公共)[6582]
   * gen by moon at 5/12/2023, 7:09:04 PM
   */
  @Trace(operationName = "D3执行强托底进入条件判断(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementJudgmentEentryConditionsStrongSupportComRespDto implementJudgmentEentryConditionsStrongSupportCom(ImplementJudgmentEentryConditionsStrongSupportComReqDto reqDto){
    
      
      OmsEvaBatchRelatedSet omsEvaBatchRelatedSet_1 =null;
//virtualUsage 3-3-01查目标详情  41173
      OmsTarget omsTarget = null;
    QueryTargetDetailReq queryTargetDetailReq=new QueryTargetDetailReq();
  queryTargetDetailReq.setIsArchive("FALSE");//sourceId:926125_1_41173
if(reqDto!=null){
      queryTargetDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:926126_1_41173
    }

    /*3-3-01查目标详情[2488]   */
    Assert.isNull(queryTargetDetailReq.getEvaluationTemplateId(),"D3执行强托底进入条件判断(公共)-3-3-01查目标详情-归属评价模板ID不能为空",false);
Assert.isNull(queryTargetDetailReq.getIsArchive(),"D3执行强托底进入条件判断(公共)-3-3-01查目标详情-是否存档不能为空",false);
      omsTarget = mOmsTargetService.queryTargetDetail(queryTargetDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      Assert.isTrue(omsTarget== null||  omsTarget.getTargetPgsStatus() ==null,"找不到数据，系统异常",false);

// TODO: 2023/8/22
if((omsTarget!= null&&  omsTarget.getTargetPgsStatus() !=null && omsTarget.getTargetPgsStatus().equals("HAS_ENDED"))) {
        //if(3-3-01查目标详情.目标进展状态 等于 已结束)  41174

//异常结束 41175
      throw new BizException("330000228","对不起评价工作已结束，不可操作！～。",false);
      }
//virtualUsage 3-3-09-03查高中基层批次设置  41065
      OmsEvaBatchRelatedSet omsEvaBatchRelatedSet = null;
    QueryPlanEvaBatchSetDetailReq queryPlanEvaBatchSetDetailReq=new QueryPlanEvaBatchSetDetailReq();
  if(reqDto!=null){
      queryPlanEvaBatchSetDetailReq.setBatchSetId(reqDto.getBatchSetId());//SimpleFieldAssign//sourceId:922510_1_41065
queryPlanEvaBatchSetDetailReq.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:922511_1_41065
    }
  
    /*3-3-09-03查高中基层批次设置[2998]   */
    Assert.isNull(queryPlanEvaBatchSetDetailReq.getBatchSetId(),"D3执行强托底进入条件判断(公共)-3-3-09-03查高中基层批次设置-批次设置对象ID不能为空",false);
Assert.isNull(queryPlanEvaBatchSetDetailReq.getThemeContentId(),"D3执行强托底进入条件判断(公共)-3-3-09-03查高中基层批次设置-主题内容ID不能为空",false);
      omsEvaBatchRelatedSet = mOmsEvaBatchRelatedSetService.queryPlanEvaBatchSetDetail(queryPlanEvaBatchSetDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      
      
      omsEvaBatchRelatedSet_1 = omsEvaBatchRelatedSet;
if((omsEvaBatchRelatedSet!= null&& omsEvaBatchRelatedSet.getUpdateTaskOrTree() != null &&omsEvaBatchRelatedSet!= null&&  omsEvaBatchRelatedSet.getUpdateTaskOrTree() !=null && omsEvaBatchRelatedSet.getUpdateTaskOrTree().equals("ONGOING"))) {
        //if((3-3-09-03查高中基层批次设置.更新任务或树状态 值不等于空  and 3-3-09-03查高中基层批次设置.更新任务或树状态 等于 进行中))  41066
        
//异常结束 41067
      throw new BizException("330000226","对不起！当前操作繁忙，稍后再来操作～。",false);
      }
ImplementJudgmentEentryConditionsStrongSupportComRespDto retData = new ImplementJudgmentEentryConditionsStrongSupportComRespDto();
  if(omsEvaBatchRelatedSet_1!=null){
      retData.setBatchRelatedSetId(omsEvaBatchRelatedSet_1.getBatchRelatedSetId());//SimpleFieldAssign//sourceId:922538_1
    }
  

  
  
return retData;
  }
/**
   * D3查询多内容操作进度列表[6563]
   * gen by moon at 5/11/2023, 8:34:24 PM
   */
  @Trace(operationName = "D3查询多内容操作进度列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryMultiContentOperateProgressListRespDto queryMultiContentOperateProgressList(QueryMultiContentOperateProgressListReqDto reqDto){


      List<OmsTargetTimingTaskDispatch> listOmsTargetTimingTaskDispatch_1 =new ArrayList<>();
if((reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("EVA_OBJECT"))) {
        //if(D3查询多内容操作进度列表.被评对象类型编码 等于 评价对象)  41180

OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setIsParentCycle("TRUE");//sourceId:925902_1_41183
queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:925904_1_41183
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:925901_1_41183
queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:926139_1_41183
queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:925903_1_41183
    }

    /*3-3-09查被评对象目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(),"D3查询多内容操作进度列表-3-3-09查被评对象目标周期详情-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3查询多内容操作进度列表-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsParentCycle(),"D3查询多内容操作进度列表-3-3-09查被评对象目标周期详情-是否父周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(),"D3查询多内容操作进度列表-3-3-09查被评对象目标周期详情-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      Assert.isTrue(omsEvaluationObjectTargetCycle== null||  omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId() ==null||omsEvaluationObjectTargetCycle== null||  omsEvaluationObjectTargetCycle.getTaskStatus() ==null,"找不到数据，系统异常",false);


if((!(omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getTaskStatus() !=null && omsEvaluationObjectTargetCycle.getTaskStatus().equals("HAS_ENDED")))) {
        //if(3-3-09查被评对象目标周期详情.目标周期任务进展状态 不等于 已结束)  41185

ObtainTargetContAutoUpdateWeightDispatchComRespDto obtainTargetContAutoUpdateWeightDispatchComRespDto = null;
    if(omsEvaluationObjectTargetCycle !=null){
          ObtainTargetContAutoUpdateWeightDispatchComReqDto obtainTargetContAutoUpdateWeightDispatchComReqDto=new ObtainTargetContAutoUpdateWeightDispatchComReqDto();
  if(omsEvaluationObjectTargetCycle!=null){
      obtainTargetContAutoUpdateWeightDispatchComReqDto.setEvaObjTargetCycleCode(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:925284_1_41188
obtainTargetContAutoUpdateWeightDispatchComReqDto.setEvaObjEntityId(omsEvaluationObjectTargetCycle.getEvaObjEntityId());//SimpleFieldAssign//sourceId:925285_1_41188
obtainTargetContAutoUpdateWeightDispatchComReqDto.setEvaObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:925286_1_41188
obtainTargetContAutoUpdateWeightDispatchComReqDto.setTargetCycleContentId(omsEvaluationObjectTargetCycle.getTargetCycleContentId());//SimpleFieldAssign//sourceId:925288_1_41188
obtainTargetContAutoUpdateWeightDispatchComReqDto.setThemeContentId(omsEvaluationObjectTargetCycle.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:925283_1_41188
    }
if(reqDto!=null){
      obtainTargetContAutoUpdateWeightDispatchComReqDto.setCustomField(reqDto.getCustomField());//SimpleFieldAssign//sourceId:925287_1_41188
    }

    /*D3获取目标内容动更新权重分调度(公共)[6556]   */
    Assert.isNull(obtainTargetContAutoUpdateWeightDispatchComReqDto.getEvaObjTargetCycleCode(),"D3查询多内容操作进度列表-D3获取目标内容动更新权重分调度(公共)-被评对象目标周期标识不能为空",false);
Assert.isNull(obtainTargetContAutoUpdateWeightDispatchComReqDto.getEvaObjEntityId(),"D3查询多内容操作进度列表-D3获取目标内容动更新权重分调度(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(obtainTargetContAutoUpdateWeightDispatchComReqDto.getEvaObjTypeCode(),"D3查询多内容操作进度列表-D3获取目标内容动更新权重分调度(公共)-被评对象类型编码不能为空",false);
Assert.isNull(obtainTargetContAutoUpdateWeightDispatchComReqDto.getTargetCycleContentId(),"D3查询多内容操作进度列表-D3获取目标内容动更新权重分调度(公共)-关联目标内容ID不能为空",false);
Assert.isNull(obtainTargetContAutoUpdateWeightDispatchComReqDto.getThemeContentId(),"D3查询多内容操作进度列表-D3获取目标内容动更新权重分调度(公共)-主题内容ID不能为空",false);
Assert.isNull(obtainTargetContAutoUpdateWeightDispatchComReqDto.getCustomField(),"D3查询多内容操作进度列表-D3获取目标内容动更新权重分调度(公共)-是否包含自身目标内容不能为空",false);
      obtainTargetContAutoUpdateWeightDispatchComRespDto = taskGenService.obtainTargetContAutoUpdateWeightDispatchCom(obtainTargetContAutoUpdateWeightDispatchComReqDto)/*vcase invoke isSameApp*/;



           }
List<OmsTargetTimingTaskDispatch> listOmsTargetTimingTaskDispatch =new ArrayList<>();
    if(obtainTargetContAutoUpdateWeightDispatchComRespDto !=null&&omsEvaluationObjectTargetCycle !=null){
          QueryTimerTaskPlanByPlanIdListReq queryTimerTaskPlanByPlanIdListReq=new QueryTimerTaskPlanByPlanIdListReq();
  if(obtainTargetContAutoUpdateWeightDispatchComRespDto!=null){
      queryTimerTaskPlanByPlanIdListReq.setTimerTaskPlanList(obtainTargetContAutoUpdateWeightDispatchComRespDto.getTimerTaskPlanList());//list-field-assign//sourceId:925783_1_41189
    }
if(omsEvaluationObjectTargetCycle!=null){
      queryTimerTaskPlanByPlanIdListReq.setThemeContentId(omsEvaluationObjectTargetCycle.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:925784_1_41189
    }

    /*3-2-09查询定时任务调度列表by调度ID[6594]   */
    Assert.isNull(queryTimerTaskPlanByPlanIdListReq.getThemeContentId(),"D3查询多内容操作进度列表-3-2-09查询定时任务调度列表by调度ID-主题内容ID不能为空",false);
      listOmsTargetTimingTaskDispatch = mOmsTargetTimingTaskDispatchService.queryTimerTaskPlanByPlanIdList(queryTimerTaskPlanByPlanIdListReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsTargetTimingTaskDispatch_1 = listOmsTargetTimingTaskDispatch;
           }
      }
      }
else if((reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("FLEVEL_OBJ_TASK_DUTY_DEPT")||reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("OKR_SUBJECT_DEPT")||reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("OKR_SUBJECT_PERSONAL"))){
       //elseif((D3查询多内容操作进度列表.被评对象类型编码 等于 一级部门目标任务责任部门 or D3查询多内容操作进度列表.被评对象类型编码 等于 OKR责任主体部门 or D3查询多内容操作进度列表.被评对象类型编码 等于 OKR责任主体个人))  41181

OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_2 = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_1=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq_1.setIsParentCycle("TRUE");//sourceId:925902_1_41182
queryEvaObjTargetCycleDetailReq_1.setIsArchive("FALSE");//sourceId:925904_1_41182
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq_1.setEvaObjTargetCycleId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:926140_1_41182
queryEvaObjTargetCycleDetailReq_1.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:925901_1_41182
queryEvaObjTargetCycleDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:925903_1_41182
    }

    /*3-3-09查被评对象目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjTypeCode(),"D3查询多内容操作进度列表-3-3-09查被评对象目标周期详情-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaluationTemplateId(),"D3查询多内容操作进度列表-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsParentCycle(),"D3查询多内容操作进度列表-3-3-09查被评对象目标周期详情-是否父周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsArchive(),"D3查询多内容操作进度列表-3-3-09查被评对象目标周期详情-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle_2 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;
      Assert.isTrue(omsEvaluationObjectTargetCycle_2== null||  omsEvaluationObjectTargetCycle_2.getEvaObjTargetCycleId() ==null||omsEvaluationObjectTargetCycle_2== null||  omsEvaluationObjectTargetCycle_2.getTaskStatus() ==null,"找不到数据，系统异常",false);


if((!(omsEvaluationObjectTargetCycle_2!= null&&  omsEvaluationObjectTargetCycle_2.getTaskStatus() !=null && omsEvaluationObjectTargetCycle_2.getTaskStatus().equals("HAS_ENDED")))) {
        //if(3-3-09查被评对象目标周期详情.目标周期任务进展状态 不等于 已结束)  41184

ObtainTargetContAutoUpdateWeightDispatchComRespDto obtainTargetContAutoUpdateWeightDispatchComRespDto_2 = null;
    if(omsEvaluationObjectTargetCycle_2 !=null){
          ObtainTargetContAutoUpdateWeightDispatchComReqDto obtainTargetContAutoUpdateWeightDispatchComReqDto_1=new ObtainTargetContAutoUpdateWeightDispatchComReqDto();
  if(omsEvaluationObjectTargetCycle_2!=null){
      obtainTargetContAutoUpdateWeightDispatchComReqDto_1.setEvaObjTargetCycleCode(omsEvaluationObjectTargetCycle_2.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:925284_1_41186
obtainTargetContAutoUpdateWeightDispatchComReqDto_1.setEvaObjEntityId(omsEvaluationObjectTargetCycle_2.getEvaObjEntityId());//SimpleFieldAssign//sourceId:925285_1_41186
obtainTargetContAutoUpdateWeightDispatchComReqDto_1.setEvaObjTypeCode(omsEvaluationObjectTargetCycle_2.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:925286_1_41186
obtainTargetContAutoUpdateWeightDispatchComReqDto_1.setTargetCycleContentId(omsEvaluationObjectTargetCycle_2.getTargetCycleContentId());//SimpleFieldAssign//sourceId:925288_1_41186
obtainTargetContAutoUpdateWeightDispatchComReqDto_1.setThemeContentId(omsEvaluationObjectTargetCycle_2.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:925283_1_41186
    }
if(reqDto!=null){
      obtainTargetContAutoUpdateWeightDispatchComReqDto_1.setCustomField(reqDto.getCustomField());//SimpleFieldAssign//sourceId:925287_1_41186
    }

    /*D3获取目标内容动更新权重分调度(公共)[6556]   */
    Assert.isNull(obtainTargetContAutoUpdateWeightDispatchComReqDto_1.getEvaObjTargetCycleCode(),"D3查询多内容操作进度列表-D3获取目标内容动更新权重分调度(公共)-被评对象目标周期标识不能为空",false);
Assert.isNull(obtainTargetContAutoUpdateWeightDispatchComReqDto_1.getEvaObjEntityId(),"D3查询多内容操作进度列表-D3获取目标内容动更新权重分调度(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(obtainTargetContAutoUpdateWeightDispatchComReqDto_1.getEvaObjTypeCode(),"D3查询多内容操作进度列表-D3获取目标内容动更新权重分调度(公共)-被评对象类型编码不能为空",false);
Assert.isNull(obtainTargetContAutoUpdateWeightDispatchComReqDto_1.getTargetCycleContentId(),"D3查询多内容操作进度列表-D3获取目标内容动更新权重分调度(公共)-关联目标内容ID不能为空",false);
Assert.isNull(obtainTargetContAutoUpdateWeightDispatchComReqDto_1.getThemeContentId(),"D3查询多内容操作进度列表-D3获取目标内容动更新权重分调度(公共)-主题内容ID不能为空",false);
Assert.isNull(obtainTargetContAutoUpdateWeightDispatchComReqDto_1.getCustomField(),"D3查询多内容操作进度列表-D3获取目标内容动更新权重分调度(公共)-是否包含自身目标内容不能为空",false);
      obtainTargetContAutoUpdateWeightDispatchComRespDto_2 = taskGenService.obtainTargetContAutoUpdateWeightDispatchCom(obtainTargetContAutoUpdateWeightDispatchComReqDto_1)/*vcase invoke isSameApp*/;



           }
List<OmsTargetTimingTaskDispatch> listOmsTargetTimingTaskDispatch_2 =new ArrayList<>();
    if(obtainTargetContAutoUpdateWeightDispatchComRespDto_2 !=null&&omsEvaluationObjectTargetCycle_2 !=null){
          QueryTimerTaskPlanByPlanIdListReq queryTimerTaskPlanByPlanIdListReq_1=new QueryTimerTaskPlanByPlanIdListReq();
  if(obtainTargetContAutoUpdateWeightDispatchComRespDto_2!=null){
      queryTimerTaskPlanByPlanIdListReq_1.setTimerTaskPlanList(obtainTargetContAutoUpdateWeightDispatchComRespDto_2.getTimerTaskPlanList());//list-field-assign//sourceId:925783_1_41187
    }
if(omsEvaluationObjectTargetCycle_2!=null){
      queryTimerTaskPlanByPlanIdListReq_1.setThemeContentId(omsEvaluationObjectTargetCycle_2.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:925784_1_41187
    }

    /*3-2-09查询定时任务调度列表by调度ID[6594]   */
    Assert.isNull(queryTimerTaskPlanByPlanIdListReq_1.getThemeContentId(),"D3查询多内容操作进度列表-3-2-09查询定时任务调度列表by调度ID-主题内容ID不能为空",false);
      listOmsTargetTimingTaskDispatch_2 = mOmsTargetTimingTaskDispatchService.queryTimerTaskPlanByPlanIdList(queryTimerTaskPlanByPlanIdListReq_1)/*vcase invoke 本地 method 方法调用;*/;


      listOmsTargetTimingTaskDispatch_1 = listOmsTargetTimingTaskDispatch_2;
           }
      }
    }
QueryMultiContentOperateProgressListRespDto retData = new QueryMultiContentOperateProgressListRespDto();
  retData.setMultiContentOperateProgressList(listOmsTargetTimingTaskDispatch_1.stream().map(item -> BeanUtil.toBean(item, MultiContentOperateProgressDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:925939_1




return retData;
  }
/**
   * D3查询单内容操作进度详情[6564]
   * gen by moon at 5/31/2023, 11:29:45 PM
   */
  @Trace(operationName = "D3查询单内容操作进度详情")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QuerySingleContentOperateProgressDetailRespDto querySingleContentOperateProgressDetail(QuerySingleContentOperateProgressDetailReqDto reqDto){


      ImplementAcceptFieldRespDto receptionServiceRes_1 =null;
ObtainProgressLoadingBgComRespDto obtainProgressLoadingBgComRespDto_1 =null;
if((reqDto!= null&& reqDto.getCustomField() == null ||reqDto!= null&&  reqDto.getCustomField() !=null && reqDto.getCustomField().equals("0"))) {
        //if((D3查询单内容操作进度详情.是任务调度 值等于空  or D3查询单内容操作进度详情.是任务调度 等于 0))  43745

     OmsEvaBatchRelatedSet omsEvaBatchRelatedSet = null;
    QueryPlanEvaBatchSetDetailReq queryPlanEvaBatchSetDetailReq=new QueryPlanEvaBatchSetDetailReq();
  if(reqDto!=null){
      queryPlanEvaBatchSetDetailReq.setBatchSetId(reqDto.getBatchSetId());//SimpleFieldAssign//sourceId:926394_1_43746
queryPlanEvaBatchSetDetailReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:926417_1_43746
    }

    /*3-3-09-03查询评价模板批次设置详情[2998]   */
    Assert.isNull(queryPlanEvaBatchSetDetailReq.getBatchSetId(),"D3查询单内容操作进度详情-3-3-09-03查询评价模板批次设置详情-批次设置对象ID不能为空",false);
Assert.isNull(queryPlanEvaBatchSetDetailReq.getThemeContentId(),"D3查询单内容操作进度详情-3-3-09-03查询评价模板批次设置详情-主题内容ID不能为空",false);
      omsEvaBatchRelatedSet = mOmsEvaBatchRelatedSetService.queryPlanEvaBatchSetDetail(queryPlanEvaBatchSetDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes = null;
    if(omsEvaBatchRelatedSet !=null){
          ImplementAcceptFieldReqDto receptionServiceReq=new ImplementAcceptFieldReqDto();
  if(omsEvaBatchRelatedSet!=null){
      receptionServiceReq.setEntityId(omsEvaBatchRelatedSet.getBatchRelatedSetId());//SimpleFieldAssign//sourceId:999758_1_43769
receptionServiceReq.setCustomField(omsEvaBatchRelatedSet.getUpdateTaskOrTree());//SimpleFieldAssign//sourceId:999759_1_43769
receptionServiceReq.setComFloatField(omsEvaBatchRelatedSet.getUpdateTaskOrTreeProgress());//SimpleFieldAssign//sourceId:999760_1_43769
    }

    /*M3接收上文出参值[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEntityId(),"D3查询单内容操作进度详情-M3接收上文出参值-内容表主键ID不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField(),"D3查询单内容操作进度详情-M3接收上文出参值-自定义字段不能为空",false);
Assert.isNull(receptionServiceReq.getComFloatField(),"D3查询单内容操作进度详情-M3接收上文出参值-通用数值字段（小数型）不能为空",false);
      receptionServiceRes = nbProgressPublicTechnicaCapacity.implementAcceptField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
     ImplementAnalyseProgressMatchScopeComRespDto implementAnalyseProgressMatchScopeComRespDto = null;
    if(omsEvaBatchRelatedSet !=null){
          ImplementAnalyseProgressMatchScopeComReqDto implementAnalyseProgressMatchScopeComReqDto=new ImplementAnalyseProgressMatchScopeComReqDto();
  if(omsEvaBatchRelatedSet!=null){
      implementAnalyseProgressMatchScopeComReqDto.setExecuteProgressValue(omsEvaBatchRelatedSet.getUpdateTaskOrTreeProgress());//SimpleFieldAssign//sourceId:999033_1_43750
    }

    /*D3分析进度值匹配进度范围[6967]   */
    Assert.isNull(implementAnalyseProgressMatchScopeComReqDto.getExecuteProgressValue(),"D3查询单内容操作进度详情-D3分析进度值匹配进度范围-执行进度值不能为空",false);
      implementAnalyseProgressMatchScopeComRespDto = executeProgressService.implementAnalyseProgressMatchScopeCom(implementAnalyseProgressMatchScopeComReqDto)/*vcase invoke isSameApp*/;



           }
     ObtainProgressLoadingBgComRespDto obtainProgressLoadingBgComRespDto = null;
    if(implementAnalyseProgressMatchScopeComRespDto !=null){
          ObtainProgressLoadingBgComReqDto obtainProgressLoadingBgComReqDto=new ObtainProgressLoadingBgComReqDto();
  obtainProgressLoadingBgComReqDto.setConfItemCode("GENERAL_PROGRESS_BG");//CUSTOM_CONVENTION//sourceId:999036_1_43751
if(implementAnalyseProgressMatchScopeComRespDto!=null){
      obtainProgressLoadingBgComReqDto.setExtensionField1(implementAnalyseProgressMatchScopeComRespDto.getCustomField());//SimpleFieldAssign//sourceId:999035_1_43751
    }

    /*D2获取进度加载背景图(公共)[6957]   */
    Assert.isNull(obtainProgressLoadingBgComReqDto.getExtensionField1(),"D3查询单内容操作进度详情-D2获取进度加载背景图(公共)-当前进度值不能为空",false);
Assert.isNull(obtainProgressLoadingBgComReqDto.getConfItemCode(),"D3查询单内容操作进度详情-D2获取进度加载背景图(公共)-配置项标识不能为空",false);
      obtainProgressLoadingBgComRespDto = fwCompConfSchemeClient.obtainProgressLoadingBgCom(obtainProgressLoadingBgComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      obtainProgressLoadingBgComRespDto_1 = obtainProgressLoadingBgComRespDto;
           }
      }
else if((reqDto!= null&&  reqDto.getCustomField() !=null && reqDto.getCustomField().equals("1"))){
       //elseif(D3查询单内容操作进度详情.是任务调度 等于 1)  43755

OmsTargetTimingTaskDispatch omsTargetTimingTaskDispatch = null;
    QueryTimerTaskPlanDetailReq queryTimerTaskPlanDetailReq=new QueryTimerTaskPlanDetailReq();
  if(reqDto!=null){
      queryTimerTaskPlanDetailReq.setTimingTaskDispatchId(reqDto.getBatchSetId());//SimpleFieldAssign//sourceId:999181_1_43756
queryTimerTaskPlanDetailReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:999182_1_43756
    }

    /*3-2-09查询定时任务调度详情[3187]   */
    Assert.isNull(queryTimerTaskPlanDetailReq.getTimingTaskDispatchId(),"D3查询单内容操作进度详情-3-2-09查询定时任务调度详情-定时任务调度记录ID不能为空",false);
Assert.isNull(queryTimerTaskPlanDetailReq.getThemeContentId(),"D3查询单内容操作进度详情-3-2-09查询定时任务调度详情-主题内容ID不能为空",false);
      omsTargetTimingTaskDispatch = mOmsTargetTimingTaskDispatchService.queryTimerTaskPlanDetail(queryTimerTaskPlanDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_2 = null;
    if(omsTargetTimingTaskDispatch !=null){
          ImplementAcceptFieldReqDto receptionServiceReq_1=new ImplementAcceptFieldReqDto();
  if(omsTargetTimingTaskDispatch!=null){
      receptionServiceReq_1.setEntityId(omsTargetTimingTaskDispatch.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:999758_1_43770
receptionServiceReq_1.setCustomField(omsTargetTimingTaskDispatch.getIsComplete());//SimpleFieldAssign//sourceId:999759_1_43770
receptionServiceReq_1.setComFloatField(omsTargetTimingTaskDispatch.getStandbyField5());//SimpleFieldAssign//sourceId:999760_1_43770
    }

    /*M3接收上文出参值[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getEntityId(),"D3查询单内容操作进度详情-M3接收上文出参值-内容表主键ID不能为空",false);
Assert.isNull(receptionServiceReq_1.getCustomField(),"D3查询单内容操作进度详情-M3接收上文出参值-自定义字段不能为空",false);
Assert.isNull(receptionServiceReq_1.getComFloatField(),"D3查询单内容操作进度详情-M3接收上文出参值-通用数值字段（小数型）不能为空",false);
      receptionServiceRes_2 = nbProgressPublicTechnicaCapacity.implementAcceptField(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
           }
ImplementAnalyseProgressMatchScopeComRespDto implementAnalyseProgressMatchScopeComRespDto_2 = null;
    if(omsTargetTimingTaskDispatch !=null){
          ImplementAnalyseProgressMatchScopeComReqDto implementAnalyseProgressMatchScopeComReqDto_1=new ImplementAnalyseProgressMatchScopeComReqDto();
  if(omsTargetTimingTaskDispatch!=null){
      implementAnalyseProgressMatchScopeComReqDto_1.setExecuteProgressValue(omsTargetTimingTaskDispatch.getStandbyField5());//SimpleFieldAssign//sourceId:999033_1_43758
    }

    /*D3分析进度值匹配进度范围[6967]   */
    Assert.isNull(implementAnalyseProgressMatchScopeComReqDto_1.getExecuteProgressValue(),"D3查询单内容操作进度详情-D3分析进度值匹配进度范围-执行进度值不能为空",false);
      implementAnalyseProgressMatchScopeComRespDto_2 = executeProgressService.implementAnalyseProgressMatchScopeCom(implementAnalyseProgressMatchScopeComReqDto_1)/*vcase invoke isSameApp*/;



           }
ObtainProgressLoadingBgComRespDto obtainProgressLoadingBgComRespDto_2 = null;
    if(implementAnalyseProgressMatchScopeComRespDto_2 !=null){
          ObtainProgressLoadingBgComReqDto obtainProgressLoadingBgComReqDto_1=new ObtainProgressLoadingBgComReqDto();
  obtainProgressLoadingBgComReqDto_1.setConfItemCode("GENERAL_PROGRESS_BG");//CUSTOM_CONVENTION//sourceId:999036_1_43763
if(implementAnalyseProgressMatchScopeComRespDto_2!=null){
      obtainProgressLoadingBgComReqDto_1.setExtensionField1(implementAnalyseProgressMatchScopeComRespDto_2.getCustomField());//SimpleFieldAssign//sourceId:999035_1_43763
    }

    /*D2获取进度加载背景图(公共)[6957]   */
    Assert.isNull(obtainProgressLoadingBgComReqDto_1.getExtensionField1(),"D3查询单内容操作进度详情-D2获取进度加载背景图(公共)-当前进度值不能为空",false);
Assert.isNull(obtainProgressLoadingBgComReqDto_1.getConfItemCode(),"D3查询单内容操作进度详情-D2获取进度加载背景图(公共)-配置项标识不能为空",false);
      obtainProgressLoadingBgComRespDto_2 = fwCompConfSchemeClient.obtainProgressLoadingBgCom(obtainProgressLoadingBgComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


      obtainProgressLoadingBgComRespDto_1 = obtainProgressLoadingBgComRespDto_2;
           }
    }
QuerySingleContentOperateProgressDetailRespDto retData = new QuerySingleContentOperateProgressDetailRespDto();
  if(receptionServiceRes_1!=null){
      retData.setEntityId(receptionServiceRes_1.getEntityId());//SimpleFieldAssign//sourceId:999767_1
retData.setProgressUpdateState(receptionServiceRes_1.getCustomField());//SimpleFieldAssign//sourceId:999768_1
retData.setCurrentUpdateProgressValue(receptionServiceRes_1.getComFloatField());//SimpleFieldAssign//sourceId:999769_1
    }
if(obtainProgressLoadingBgComRespDto_1!=null){
      retData.setBackGroundAddress(obtainProgressLoadingBgComRespDto_1.getBackGroundAddress());//SimpleFieldAssign//sourceId:999039_1
    }




return retData;
  }
/**
   * D3执行初始化进度值(公共)[6973]
   * gen by moon at 5/31/2023, 2:04:54 AM
   */
  @Trace(operationName = "D3执行初始化进度值(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementInitializeProgressValueComRespDto implementInitializeProgressValueCom(ImplementInitializeProgressValueComReqDto reqDto){


      if((reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("TOP_UPDATE_TASK_PROGRESS")||reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("TOP_UPDATE_OKR_SUBJECT_PERSONAL")||reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("TOP_UPDATE_PARENT_STATE")||reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("MID_UPDATE_FLEVEL_OBJ_TASK_DUTY_DEPT")||reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("MID_UPDATE_ OKR_SUBJECT_DEPT")||reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("MID_UPDATE_OKR_SUBJECT_DEPT")||reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("MID_UPDATE_OKR_SUBJECT_PERSONAL")||reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("MID_BASIC_UPDATE_PARENT_STATE")||reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("DEPT_TARGET_BOOK_UPDATE_PARENT_STATE"))) {
        //if((D3执行初始化进度值(公共).托底更新进度场景 等于 高层托底更新汇报任务 or D3执行初始化进度值(公共).托底更新进度场景 等于 高层托底更新OKR个人树 or D3执行初始化进度值(公共).托底更新进度场景 等于 高层托底更新父子状态等 or D3执行初始化进度值(公共).托底更新进度场景 等于 中层托底更新部门目标任务书树 or D3执行初始化进度值(公共).托底更新进度场景 等于 中层托底更新OKR部门树 or D3执行初始化进度值(公共).托底更新进度场景 等于 基层部门托底更新OKR部门树 or D3执行初始化进度值(公共).托底更新进度场景 等于 基层托底更新OKR个人树 or D3执行初始化进度值(公共).托底更新进度场景 等于 中基层托底更新父子状态等 or D3执行初始化进度值(公共).托底更新进度场景 等于 部门目标任务书树更新父子状态))  43240

boolean bOOLEAN ;
    OmsEvaBatchRelatedSet omsEvaBatchRelatedSet=new OmsEvaBatchRelatedSet();
  omsEvaBatchRelatedSet.setUpdateTaskOrTreeProgress(Double.valueOf("0"));//CUSTOM_CONVENTION//sourceId:987302_1_43241
omsEvaBatchRelatedSet.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:987303_1_43241
omsEvaBatchRelatedSet.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:987304_1_43241
if(reqDto!=null){
      omsEvaBatchRelatedSet.setBatchRelatedSetId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:987301_1_43241
    }

    /*3-3-09-03初始化高中基层评批次设置进度值[3034]   */
    Assert.isNull(omsEvaBatchRelatedSet.getBatchRelatedSetId(),"D3执行初始化进度值(公共)-3-3-09-03初始化高中基层评批次设置进度值-批次相关设置ID不能为空",false);
Assert.isNull(omsEvaBatchRelatedSet.getUpdateTaskOrTreeProgress(),"D3执行初始化进度值(公共)-3-3-09-03初始化高中基层评批次设置进度值-更新任务或树处理进度不能为空",false);
Assert.isNull(omsEvaBatchRelatedSet.getOperationInductionId(),"D3执行初始化进度值(公共)-3-3-09-03初始化高中基层评批次设置进度值-操作人就职记录ID不能为空",false);
Assert.isNull(omsEvaBatchRelatedSet.getOperateTime(),"D3执行初始化进度值(公共)-3-3-09-03初始化高中基层评批次设置进度值-操作时间不能为空",false);
      bOOLEAN = mOmsEvaBatchRelatedSetService.updatePlanEvaBatchSet(omsEvaBatchRelatedSet)/*vcase invoke 本地 method 方法调用;*/;



      }
else if((reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("TOP_UPDATE_WEIGHT_SCORE")||reqDto!= null&&  reqDto.getUpdateProgressSence() !=null && reqDto.getUpdateProgressSence().equals("TOP_UPDATE_FLEVEL_OBJ_TASK_DUTY_DEPT"))){
       //elseif((D3执行初始化进度值(公共).托底更新进度场景 等于 托底更新权重分 or D3执行初始化进度值(公共).托底更新进度场景 等于 托底更新部门目标任务书权重分))  43242

boolean bOOLEAN_1 ;
    OmsTargetTimingTaskDispatch omsTargetTimingTaskDispatch=new OmsTargetTimingTaskDispatch();
  omsTargetTimingTaskDispatch.setStandbyField5(Double.valueOf("0"));//CUSTOM_CONVENTION//sourceId:987322_1_43243
omsTargetTimingTaskDispatch.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:987319_1_43243
omsTargetTimingTaskDispatch.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:987320_1_43243
if(reqDto!=null){
      omsTargetTimingTaskDispatch.setTimingTaskDispatchId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:987318_1_43243
    }

    /*3-2-09初始化调度里面进度值[3186]   */
    Assert.isNull(omsTargetTimingTaskDispatch.getTimingTaskDispatchId(),"D3执行初始化进度值(公共)-3-2-09初始化调度里面进度值-定时任务调度记录ID不能为空",false);
Assert.isNull(omsTargetTimingTaskDispatch.getStandbyField5(),"D3执行初始化进度值(公共)-3-2-09初始化调度里面进度值-备用字段5不能为空",false);
Assert.isNull(omsTargetTimingTaskDispatch.getOperationInductionId(),"D3执行初始化进度值(公共)-3-2-09初始化调度里面进度值-操作人就职记录ID不能为空",false);
Assert.isNull(omsTargetTimingTaskDispatch.getOperateTime(),"D3执行初始化进度值(公共)-3-2-09初始化调度里面进度值-操作时间不能为空",false);
      bOOLEAN_1 = mOmsTargetTimingTaskDispatchService.refreshTimerTaskPlan(omsTargetTimingTaskDispatch)/*vcase invoke 本地 method 方法调用;*/;



    }
ImplementInitializeProgressValueComRespDto retData = new ImplementInitializeProgressValueComRespDto();





return retData;
  }
/**
   * D3分析托底更新权重进度场景(公共)[7029]
   * gen by moon at 5/31/2023, 2:05:12 AM
   */
  @Trace(operationName = "D3分析托底更新权重进度场景(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementAnalyseTorrUpdateWeightProgressSceneComRespDto implementAnalyseTorrUpdateWeightProgressSceneCom(ImplementAnalyseTorrUpdateWeightProgressSceneComReqDto reqDto){


      ImplementAcceptFieldRespDto receptionServiceRes_3 =null;
if((reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("FLEVEL_OBJ_TASK_DUTY_DEPT"))) {
        //if(D3分析托底更新权重进度场景(公共).被评对象类型编码 等于 一级部门目标任务责任部门)  43549

//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes = null;
    ImplementAcceptFieldReqDto receptionServiceReq=new ImplementAcceptFieldReqDto();
  receptionServiceReq.setUpdateProgressSence("TOP_UPDATE_FLEVEL_OBJ_TASK_DUTY_DEPT");//sourceId:994434_1_43550

    /*M3约定为：托底更新部门目标任务书权重分[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getUpdateProgressSence(),"D3分析托底更新权重进度场景(公共)-M3约定为：托底更新部门目标任务书权重分-托底更新进度场景不能为空",false);
      receptionServiceRes = nbProgressPublicTechnicaCapacity.implementAcceptField(receptionServiceReq);



//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_2 = null;
    ImplementAcceptFieldReqDto receptionServiceReq_1=new ImplementAcceptFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_1.setUpdateProgressSence(receptionServiceRes.getUpdateProgressSence());//SimpleFieldAssign//sourceId:994439_1_43554
    }

    /*M3接收上文出参[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getUpdateProgressSence(),"D3分析托底更新权重进度场景(公共)-M3接收上文出参-托底更新进度场景不能为空",false);
      receptionServiceRes_2 = nbProgressPublicTechnicaCapacity.implementAcceptField(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
      }
else if((reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("EVA_OBJECT"))){
       //elseif(D3分析托底更新权重进度场景(公共).被评对象类型编码 等于 评价对象)  43551

//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_4 = null;
    ImplementAcceptFieldReqDto receptionServiceReq_2=new ImplementAcceptFieldReqDto();
  receptionServiceReq_2.setUpdateProgressSence("TOP_UPDATE_WEIGHT_SCORE");//sourceId:994430_1_43552

    /*M3约定为托底更新权重分[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getUpdateProgressSence(),"D3分析托底更新权重进度场景(公共)-M3约定为托底更新权重分-托底更新进度场景不能为空",false);
      receptionServiceRes_4 = nbProgressPublicTechnicaCapacity.implementAcceptField(receptionServiceReq_2);



//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_6 = null;
    ImplementAcceptFieldReqDto receptionServiceReq_3=new ImplementAcceptFieldReqDto();
  if(receptionServiceRes_4!=null){
      receptionServiceReq_3.setUpdateProgressSence(receptionServiceRes_4.getUpdateProgressSence());//SimpleFieldAssign//sourceId:994439_1_43553
    }

    /*M3接收上文出参[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getUpdateProgressSence(),"D3分析托底更新权重进度场景(公共)-M3接收上文出参-托底更新进度场景不能为空",false);
      receptionServiceRes_6 = nbProgressPublicTechnicaCapacity.implementAcceptField(receptionServiceReq_3);


      receptionServiceRes_3 = receptionServiceRes_6;
    }
ImplementAnalyseTorrUpdateWeightProgressSceneComRespDto retData = new ImplementAnalyseTorrUpdateWeightProgressSceneComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setUpdateProgressSence(receptionServiceRes_3.getUpdateProgressSence());//SimpleFieldAssign//sourceId:994448_1
    }




return retData;
  }
/**
   * D3执行更新任务或树状态(公共)[7137]
   * gen by moon at 6/5/2023, 8:50:02 PM
   */
  @Trace(operationName = "D3执行更新任务或树状态(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementUpdateTaskOTreeStateComRespDto implementUpdateTaskOTreeStateCom(ImplementUpdateTaskOTreeStateComReqDto reqDto){


      //步骤0: M3异步开始（特殊方法） - addAsynchronizationStart
     //ModelCode: asynchronizationStart
Callable<String> call = new Callable<String>() {

    @Override
    public String call() throws Exception {
        //执行方法

//步骤1: 3-3-09-03修改评价模板批次设置 - updatePlanEvaBatchSet
     boolean bOOLEAN ;
    OmsEvaBatchRelatedSet omsEvaBatchRelatedSet=new OmsEvaBatchRelatedSet();
  omsEvaBatchRelatedSet.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1011413_1
if(reqDto!=null){
      omsEvaBatchRelatedSet.setBatchRelatedSetId(reqDto.getBatchRelatedSetId());//SimpleFieldAssign//sourceId:1011391_1
omsEvaBatchRelatedSet.setUpdateTaskOrTree(reqDto.getUpdateTaskOrTree());//SimpleFieldAssign//sourceId:1011412_1
omsEvaBatchRelatedSet.setOperationInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:1011395_1
    }

    /*3-3-09-03修改评价模板批次设置[3034]   */
    Assert.isNull(omsEvaBatchRelatedSet.getBatchRelatedSetId(),"D3执行更新任务或树状态(公共)-3-3-09-03修改评价模板批次设置-批次相关设置ID不能为空",false);
Assert.isNull(omsEvaBatchRelatedSet.getUpdateTaskOrTree(),"D3执行更新任务或树状态(公共)-3-3-09-03修改评价模板批次设置-更新任务或树状态不能为空",false);
Assert.isNull(omsEvaBatchRelatedSet.getOperationInductionId(),"D3执行更新任务或树状态(公共)-3-3-09-03修改评价模板批次设置-操作人就职记录ID不能为空",false);
Assert.isNull(omsEvaBatchRelatedSet.getOperateTime(),"D3执行更新任务或树状态(公共)-3-3-09-03修改评价模板批次设置-操作时间不能为空",false);
      bOOLEAN = mOmsEvaBatchRelatedSetService.updatePlanEvaBatchSet(omsEvaBatchRelatedSet)/*vcase invoke 本地 method 方法调用;*/;




//步骤2: M3异步结束（特殊方法） - addAsynchronizationEnd
     //ModelCode: asynchronizationEnd
        return "";
    }
};
CommonFunctionHelper.asynExcute(call);

ImplementUpdateTaskOTreeStateComRespDto retData = new ImplementUpdateTaskOTreeStateComRespDto();





return retData;
  }
  //
}
